import { ElMessage } from 'element-plus';

/**
 * 错误处理工具类
 */
export class ErrorHandler {
  /**
   * 提取错误信息
   * @param error 错误对象
   * @param defaultMessage 默认错误信息
   * @returns 格式化后的错误信息
   */
  static extractErrorMessage(error: any, defaultMessage: string = '操作失败'): string {
    if (!error) return defaultMessage;
    
    // 处理API响应错误
    if (error.response?.data) {
      const errorData = error.response.data;
      
      // 处理验证错误
      if (errorData.errors) {
        const validationErrors = Object.values(errorData.errors).flat();
        return `验证错误: ${validationErrors.join(', ')}`;
      }
      
      // 处理详细错误信息
      if (errorData.details) {
        return `${errorData.message || '错误'}: ${errorData.details}`;
      }
      
      // 处理普通错误信息
      return errorData.message || defaultMessage;
    }
    
    // 处理普通错误
    if (error.message) {
      return error.message;
    }
    
    return defaultMessage;
  }

  /**
   * 显示错误消息
   * @param error 错误对象
   * @param defaultMessage 默认错误信息
   */
  static showError(error: any, defaultMessage: string = '操作失败'): void {
    const message = this.extractErrorMessage(error, defaultMessage);
    ElMessage.error(message);
  }

  /**
   * 处理API响应
   * @param response API响应
   * @param successMessage 成功消息
   * @param errorMessage 错误消息
   * @returns 是否成功
   */
  static handleApiResponse(
    response: any, 
    successMessage?: string, 
    errorMessage: string = '操作失败'
  ): boolean {
    if (response.Code === 200) {
      if (successMessage) {
        ElMessage.success(successMessage);
      }
      return true;
    } else {
      ElMessage.error(response.Message || errorMessage);
      return false;
    }
  }

  /**
   * 安全执行异步操作
   * @param operation 异步操作函数
   * @param errorMessage 错误消息
   * @param showError 是否显示错误消息
   * @returns 操作结果
   */
  static async safeExecute<T>(
    operation: () => Promise<T>,
    errorMessage: string = '操作失败',
    showError: boolean = true
  ): Promise<T | null> {
    try {
      return await operation();
    } catch (error) {
      console.error(errorMessage, error);
      if (showError) {
        this.showError(error, errorMessage);
      }
      return null;
    }
  }

  /**
   * 处理批量操作
   * @param operations 操作数组
   * @param successMessage 成功消息
   * @param errorMessage 错误消息
   * @returns 是否全部成功
   */
  static async handleBatchOperations(
    operations: (() => Promise<any>)[],
    successMessage: string = '批量操作成功',
    errorMessage: string = '批量操作失败'
  ): Promise<boolean> {
    try {
      await Promise.all(operations.map(op => op()));
      ElMessage.success(successMessage);
      return true;
    } catch (error) {
      console.error(errorMessage, error);
      this.showError(error, errorMessage);
      return false;
    }
  }
}

/**
 * 简化的错误处理函数
 */
export const showError = (error: any, defaultMessage?: string) => 
  ErrorHandler.showError(error, defaultMessage);

export const extractErrorMessage = (error: any, defaultMessage?: string) => 
  ErrorHandler.extractErrorMessage(error, defaultMessage);

export const handleApiResponse = (response: any, successMessage?: string, errorMessage?: string) => 
  ErrorHandler.handleApiResponse(response, successMessage, errorMessage);

export const safeExecute = <T>(operation: () => Promise<T>, errorMessage?: string, showError?: boolean) => 
  ErrorHandler.safeExecute(operation, errorMessage, showError);
